/**
 * jscolor - JavaScript Color Picker
 *
 * @link    http://jscolor.com
 * @license For open source use: GPLv3
 *          For commercial use: JSColor Commercial License
 * @author  Jan Odvarko
 * @version 2.0.4
 *
 * See usage examples at http://jscolor.com/examples/
 */
!function(dependencies,factory){
	// amd || cmd
	if(typeof define == 'function' && (define.cmd || define.amd)) {
		define(dependencies,function() {
			return factory();
		});
	}
	else {
		var ex = factory();
		// CommonJS NodeJS
		if(typeof module !== 'undefined' && typeof exports === 'object') {
			module.exports = ex;
		}
	}
}(['jquery'],function() {

	"use strict";

	var jsc = {


		register: function () {
			jsc.attachDOMReadyEvent(jsc.init);
			jsc.attachEvent(document, 'mousedown', jsc.onDocumentMouseDown);
			jsc.attachEvent(document, 'touchstart', jsc.onDocumentTouchStart);
			jsc.attachEvent(window, 'resize', jsc.onWindowResize);
		},


		init: function () {
			if (jsc.jscolor.lookupClass) {
				jsc.jscolor.installByClassName(jsc.jscolor.lookupClass);
			}
		},


		tryInstallOnElements: function (elms, className) {
			var matchClass = new RegExp('(^|\\s)(' + className + ')(\\s*(\\{[^}]*\\})|\\s|$)', 'i');

			for (var i = 0; i < elms.length; i += 1) {
				if (elms[i].type !== undefined && elms[i].type.toLowerCase() == 'color') {
					if (jsc.isColorAttrSupported) {
						// skip inputs of type 'color' if supported by the browser
						continue;
					}
				}
				var m;
				if (!elms[i].jscolor && elms[i].className && (m = elms[i].className.match(matchClass))) {
					var targetElm = elms[i];
					var optsStr = null;

					var dataOptions = jsc.getDataAttr(targetElm, 'jscolor');
					if (dataOptions !== null) {
						optsStr = dataOptions;
					} else if (m[4]) {
						optsStr = m[4];
					}

					var opts = {};
					if (optsStr) {
						try {
							opts = (new Function('return (' + optsStr + ')'))();
						} catch (eParseError) {
							jsc.warn('Error parsing jscolor options: ' + eParseError + ':\n' + optsStr);
						}
					}
					targetElm.jscolor = new jsc.jscolor(targetElm, opts);
				}
			}
		},


		isColorAttrSupported: (function () {
			var elm = document.createElement('input');
			if (elm.setAttribute) {
				elm.setAttribute('type', 'color');
				if (elm.type.toLowerCase() == 'color') {
					return true;
				}
			}
			return false;
		})(),


		isCanvasSupported: (function () {
			var elm = document.createElement('canvas');
			return !!(elm.getContext && elm.getContext('2d'));
		})(),


		fetchElement: function (mixed) {
			return typeof mixed === 'string' ? document.getElementById(mixed) : mixed;
		},


		isElementType: function (elm, type) {
			return elm.nodeName.toLowerCase() === type.toLowerCase();
		},


		getDataAttr: function (el, name) {
			var attrName = 'data-' + name;
			var attrValue = el.getAttribute(attrName);
			if (attrValue !== null) {
				return attrValue;
			}
			return null;
		},


		attachEvent: function (el, evnt, func) {
			if (el.addEventListener) {
				el.addEventListener(evnt, func, false);
			} else if (el.attachEvent) {
				el.attachEvent('on' + evnt, func);
			}
		},


		detachEvent: function (el, evnt, func) {
			if (el.removeEventListener) {
				el.removeEventListener(evnt, func, false);
			} else if (el.detachEvent) {
				el.detachEvent('on' + evnt, func);
			}
		},


		_attachedGroupEvents: {},


		attachGroupEvent: function (groupName, el, evnt, func) {
			if (!jsc._attachedGroupEvents.hasOwnProperty(groupName)) {
				jsc._attachedGroupEvents[groupName] = [];
			}
			jsc._attachedGroupEvents[groupName].push([el, evnt, func]);
			jsc.attachEvent(el, evnt, func);
		},


		detachGroupEvents: function (groupName) {
			if (jsc._attachedGroupEvents.hasOwnProperty(groupName)) {
				for (var i = 0; i < jsc._attachedGroupEvents[groupName].length; i += 1) {
					var evt = jsc._attachedGroupEvents[groupName][i];
					jsc.detachEvent(evt[0], evt[1], evt[2]);
				}
				delete jsc._attachedGroupEvents[groupName];
			}
		},


		attachDOMReadyEvent: function (func) {
			var fired = false;
			var fireOnce = function () {
				if (!fired) {
					fired = true;
					func();
				}
			};

			if (document.readyState === 'complete') {
				setTimeout(fireOnce, 1); // async
				return;
			}

			if (document.addEventListener) {
				document.addEventListener('DOMContentLoaded', fireOnce, false);

				// Fallback
				window.addEventListener('load', fireOnce, false);

			} else if (document.attachEvent) {
				// IE
				document.attachEvent('onreadystatechange', function () {
					if (document.readyState === 'complete') {
						document.detachEvent('onreadystatechange', arguments.callee);
						fireOnce();
					}
				})

				// Fallback
				window.attachEvent('onload', fireOnce);

				// IE7/8
				if (document.documentElement.doScroll && window == window.top) {
					var tryScroll = function () {
						if (!document.body) {
							return;
						}
						try {
							document.documentElement.doScroll('left');
							fireOnce();
						} catch (e) {
							setTimeout(tryScroll, 1);
						}
					};
					tryScroll();
				}
			}
		},


		warn: function (msg) {
			if (window.console && window.console.warn) {
				window.console.warn(msg);
			}
		},


		preventDefault: function (e) {
			if (e.preventDefault) {
				e.preventDefault();
			}
			e.returnValue = false;
		},


		captureTarget: function (target) {
			// IE
			if (target.setCapture) {
				jsc._capturedTarget = target;
				jsc._capturedTarget.setCapture();
			}
		},


		releaseTarget: function () {
			// IE
			if (jsc._capturedTarget) {
				jsc._capturedTarget.releaseCapture();
				jsc._capturedTarget = null;
			}
		},


		fireEvent: function (el, evnt) {
			if (!el) {
				return;
			}
			if (document.createEvent) {
				var ev = document.createEvent('HTMLEvents');
				ev.initEvent(evnt, true, true);
				el.dispatchEvent(ev);
			} else if (document.createEventObject) {
				var ev = document.createEventObject();
				el.fireEvent('on' + evnt, ev);
			} else if (el['on' + evnt]) { // alternatively use the traditional event model
				el['on' + evnt]();
			}
		},


		classNameToList: function (className) {
			return className.replace(/^\s+|\s+$/g, '').split(/\s+/);
		},


		// The className parameter (str) can only contain a single class name
		hasClass: function (elm, className) {
			if (!className) {
				return false;
			}
			return -1 != (' ' + elm.className.replace(/\s+/g, ' ') + ' ').indexOf(' ' + className + ' ');
		},


		// The className parameter (str) can contain multiple class names separated by whitespace
		setClass: function (elm, className) {
			var classList = jsc.classNameToList(className);
			for (var i = 0; i < classList.length; i += 1) {
				if (!jsc.hasClass(elm, classList[i])) {
					elm.className += (elm.className ? ' ' : '') + classList[i];
				}
			}
		},


		// The className parameter (str) can contain multiple class names separated by whitespace
		unsetClass: function (elm, className) {
			var classList = jsc.classNameToList(className);
			for (var i = 0; i < classList.length; i += 1) {
				var repl = new RegExp(
					'^\\s*' + classList[i] + '\\s*|' +
					'\\s*' + classList[i] + '\\s*$|' +
					'\\s+' + classList[i] + '(\\s+)',
					'g'
				);
				elm.className = elm.className.replace(repl, '$1');
			}
		},


		getStyle: function (elm) {
			return window.getComputedStyle ? window.getComputedStyle(elm) : elm.currentStyle;
		},


		setStyle: (function () {
			var helper = document.createElement('div');
			var getSupportedProp = function (names) {
				for (var i = 0; i < names.length; i += 1) {
					if (names[i] in helper.style) {
						return names[i];
					}
				}
			};
			var props = {
				borderRadius: getSupportedProp(['borderRadius', 'MozBorderRadius', 'webkitBorderRadius']),
				boxShadow: getSupportedProp(['boxShadow', 'MozBoxShadow', 'webkitBoxShadow'])
			};
			return function (elm, prop, value) {
				switch (prop.toLowerCase()) {
					case 'opacity':
						var alphaOpacity = Math.round(parseFloat(value) * 100);
						elm.style.opacity = value;
						elm.style.filter = 'alpha(opacity=' + alphaOpacity + ')';
						break;
					default:
						elm.style[props[prop]] = value;
						break;
				}
			};
		})(),


		setBorderRadius: function (elm, value) {
			jsc.setStyle(elm, 'borderRadius', value || '0');
		},


		setBoxShadow: function (elm, value) {
			jsc.setStyle(elm, 'boxShadow', value || 'none');
		},


		getElementPos: function (e, relativeToViewport) {
			var x = 0, y = 0;
			var rect = e.getBoundingClientRect();
			x = rect.left;
			y = rect.top;
			if (!relativeToViewport) {
				var viewPos = jsc.getViewPos();
				x += viewPos[0];
				y += viewPos[1];
			}
			return [x, y];
		},


		getElementSize: function (e) {
			return [e.offsetWidth, e.offsetHeight];
		},


		// get pointer's X/Y coordinates relative to viewport
		getAbsPointerPos: function (e) {
			if (!e) {
				e = window.event;
			}
			var x = 0, y = 0;
			if (typeof e.changedTouches !== 'undefined' && e.changedTouches.length) {
				// touch devices
				x = e.changedTouches[0].clientX;
				y = e.changedTouches[0].clientY;
			} else if (typeof e.clientX === 'number') {
				x = e.clientX;
				y = e.clientY;
			}
			return {x: x, y: y};
		},


		// get pointer's X/Y coordinates relative to target element
		getRelPointerPos: function (e) {
			if (!e) {
				e = window.event;
			}
			var target = e.target || e.srcElement;
			var targetRect = target.getBoundingClientRect();

			var x = 0, y = 0;

			var clientX = 0, clientY = 0;
			if (typeof e.changedTouches !== 'undefined' && e.changedTouches.length) {
				// touch devices
				clientX = e.changedTouches[0].clientX;
				clientY = e.changedTouches[0].clientY;
			} else if (typeof e.clientX === 'number') {
				clientX = e.clientX;
				clientY = e.clientY;
			}

			x = clientX - targetRect.left;
			y = clientY - targetRect.top;
			return {x: x, y: y};
		},


		getViewPos: function () {
			var doc = document.documentElement;
			return [
				(window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0),
				(window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0)
			];
		},


		getViewSize: function () {
			var doc = document.documentElement;
			return [
				(window.innerWidth || doc.clientWidth),
				(window.innerHeight || doc.clientHeight),
			];
		},


		redrawPosition: function () {

			if (jsc.picker && jsc.picker.owner) {
				var thisObj = jsc.picker.owner;

				var tp, vp;

				if (thisObj.fixed) {
					// Fixed elements are positioned relative to viewport,
					// therefore we can ignore the scroll offset
					tp = jsc.getElementPos(thisObj.targetElement, true); // target pos
					vp = [0, 0]; // view pos
				} else {
					tp = jsc.getElementPos(thisObj.targetElement); // target pos
					vp = jsc.getViewPos(); // view pos
				}

				var ts = jsc.getElementSize(thisObj.targetElement); // target size
				var vs = jsc.getViewSize(); // view size
				var ps = jsc.getPickerOuterDims(thisObj); // picker size
				var a, b, c;
				switch (thisObj.position.toLowerCase()) {
					case 'left':
						a = 1;
						b = 0;
						c = -1;
						break;
					case 'right':
						a = 1;
						b = 0;
						c = 1;
						break;
					case 'top':
						a = 0;
						b = 1;
						c = -1;
						break;
					default:
						a = 0;
						b = 1;
						c = 1;
						break;
				}
				var l = (ts[b] + ps[b]) / 2;

				// compute picker position
				if (!thisObj.smartPosition) {
					var pp = [
						tp[a],
						tp[b] + ts[b] - l + l * c
					];
				} else {
					var pp = [
						-vp[a] + tp[a] + ps[a] > vs[a] ?
							(-vp[a] + tp[a] + ts[a] / 2 > vs[a] / 2 && tp[a] + ts[a] - ps[a] >= 0 ? tp[a] + ts[a] - ps[a] : tp[a]) :
							tp[a],
						-vp[b] + tp[b] + ts[b] + ps[b] - l + l * c > vs[b] ?
							(-vp[b] + tp[b] + ts[b] / 2 > vs[b] / 2 && tp[b] + ts[b] - l - l * c >= 0 ? tp[b] + ts[b] - l - l * c : tp[b] + ts[b] - l + l * c) :
							(tp[b] + ts[b] - l + l * c >= 0 ? tp[b] + ts[b] - l + l * c : tp[b] + ts[b] - l - l * c)
					];
				}

				var x = pp[a];
				var y = pp[b];
				var positionValue = thisObj.fixed ? 'fixed' : 'absolute';
				var contractShadow =
					(pp[0] + ps[0] > tp[0] || pp[0] < tp[0] + ts[0]) &&
					(pp[1] + ps[1] < tp[1] + ts[1]);

				jsc._drawPosition(thisObj, x, y, positionValue, contractShadow);
			}
		},


		_drawPosition: function (thisObj, x, y, positionValue, contractShadow) {
			var vShadow = contractShadow ? 0 : thisObj.shadowBlur; // px

			jsc.picker.wrap.style.position = positionValue;
			jsc.picker.wrap.style.left = x + 'px';
			jsc.picker.wrap.style.top = y + 'px';

			jsc.setBoxShadow(
				jsc.picker.boxS,
				thisObj.shadow ?
					new jsc.BoxShadow(0, vShadow, thisObj.shadowBlur, 0, thisObj.shadowColor) :
					null);
		},


		getPickerDims: function (thisObj) {
			var displaySlider = !!jsc.getSliderComponent(thisObj);
			var dims = [
				2 * thisObj.insetWidth + 2 * thisObj.padding + thisObj.width +
				(displaySlider ? 2 * thisObj.insetWidth + jsc.getPadToSliderPadding(thisObj) + thisObj.sliderSize : 0),
				2 * thisObj.insetWidth + 2 * thisObj.padding + thisObj.height +
				(thisObj.closable ? 2 * thisObj.insetWidth + thisObj.padding + thisObj.buttonHeight : 0)
			];
			return dims;
		},


		getPickerOuterDims: function (thisObj) {
			var dims = jsc.getPickerDims(thisObj);
			return [
				dims[0] + 2 * thisObj.borderWidth,
				dims[1] + 2 * thisObj.borderWidth
			];
		},


		getPadToSliderPadding: function (thisObj) {
			return Math.max(thisObj.padding, 1.5 * (2 * thisObj.pointerBorderWidth + thisObj.pointerThickness));
		},


		getPadYComponent: function (thisObj) {
			switch (thisObj.mode.charAt(1).toLowerCase()) {
				case 'v':
					return 'v';
					break;
			}
			return 's';
		},


		getSliderComponent: function (thisObj) {
			if (thisObj.mode.length > 2) {
				switch (thisObj.mode.charAt(2).toLowerCase()) {
					case 's':
						return 's';
						break;
					case 'v':
						return 'v';
						break;
				}
			}
			return null;
		},


		onDocumentMouseDown: function (e) {
			if (!e) {
				e = window.event;
			}
			var target = e.target || e.srcElement;

			if (target._jscLinkedInstance) {
				if (target._jscLinkedInstance.showOnClick) {
					target._jscLinkedInstance.show();
				}
			} else if (target._jscControlName) {
				jsc.onControlPointerStart(e, target, target._jscControlName, 'mouse');
			} else {
				// Mouse is outside the picker controls -> hide the color picker!
				if (jsc.picker && jsc.picker.owner) {
					jsc.picker.owner.hide();
				}
			}
		},


		onDocumentTouchStart: function (e) {
			if (!e) {
				e = window.event;
			}
			var target = e.target || e.srcElement;

			if (target._jscLinkedInstance) {
				if (target._jscLinkedInstance.showOnClick) {
					target._jscLinkedInstance.show();
				}
			} else if (target._jscControlName) {
				jsc.onControlPointerStart(e, target, target._jscControlName, 'touch');
			} else {
				if (jsc.picker && jsc.picker.owner) {
					jsc.picker.owner.hide();
				}
			}
		},


		onWindowResize: function (e) {
			jsc.redrawPosition();
		},


		onParentScroll: function (e) {
			// hide the picker when one of the parent elements is scrolled
			if (jsc.picker && jsc.picker.owner) {
				jsc.picker.owner.hide();
			}
		},


		_pointerMoveEvent: {
			mouse: 'mousemove',
			touch: 'touchmove'
		},
		_pointerEndEvent: {
			mouse: 'mouseup',
			touch: 'touchend'
		},


		_pointerOrigin: null,
		_capturedTarget: null,


		onControlPointerStart: function (e, target, controlName, pointerType) {
			var thisObj = target._jscInstance;

			jsc.preventDefault(e);
			jsc.captureTarget(target);

			var registerDragEvents = function (doc, offset) {
				jsc.attachGroupEvent('drag', doc, jsc._pointerMoveEvent[pointerType],
					jsc.onDocumentPointerMove(e, target, controlName, pointerType, offset));
				jsc.attachGroupEvent('drag', doc, jsc._pointerEndEvent[pointerType],
					jsc.onDocumentPointerEnd(e, target, controlName, pointerType));
			};

			registerDragEvents(document, [0, 0]);

			if (window.parent && window.frameElement) {
				var rect = window.frameElement.getBoundingClientRect();
				var ofs = [-rect.left, -rect.top];
				registerDragEvents(window.parent.window.document, ofs);
			}

			var abs = jsc.getAbsPointerPos(e);
			var rel = jsc.getRelPointerPos(e);
			jsc._pointerOrigin = {
				x: abs.x - rel.x,
				y: abs.y - rel.y
			};

			switch (controlName) {
				case 'pad':
					// if the slider is at the bottom, move it up
					switch (jsc.getSliderComponent(thisObj)) {
						case 's':
							if (thisObj.hsv[1] === 0) {
								thisObj.fromHSV(null, 100, null);
							}
							;
							break;
						case 'v':
							if (thisObj.hsv[2] === 0) {
								thisObj.fromHSV(null, null, 100);
							}
							;
							break;
					}
					jsc.setPad(thisObj, e, 0, 0);
					break;

				case 'sld':
					jsc.setSld(thisObj, e, 0);
					break;
			}

			jsc.dispatchFineChange(thisObj);
		},


		onDocumentPointerMove: function (e, target, controlName, pointerType, offset) {
			return function (e) {
				var thisObj = target._jscInstance;
				switch (controlName) {
					case 'pad':
						if (!e) {
							e = window.event;
						}
						jsc.setPad(thisObj, e, offset[0], offset[1]);
						jsc.dispatchFineChange(thisObj);
						break;

					case 'sld':
						if (!e) {
							e = window.event;
						}
						jsc.setSld(thisObj, e, offset[1]);
						jsc.dispatchFineChange(thisObj);
						break;
				}
			}
		},


		onDocumentPointerEnd: function (e, target, controlName, pointerType) {
			return function (e) {
				var thisObj = target._jscInstance;
				jsc.detachGroupEvents('drag');
				jsc.releaseTarget();
				// Always dispatch changes after detaching outstanding mouse handlers,
				// in case some user interaction will occur in user's onchange callback
				// that would intrude with current mouse events
				jsc.dispatchChange(thisObj);
			};
		},


		dispatchChange: function (thisObj) {
			if (thisObj.valueElement) {
				if (jsc.isElementType(thisObj.valueElement, 'input')) {
					jsc.fireEvent(thisObj.valueElement, 'change');
				}
			}
		},


		dispatchFineChange: function (thisObj) {
			if (thisObj.onFineChange) {
				var callback;
				if (typeof thisObj.onFineChange === 'string') {
					callback = new Function(thisObj.onFineChange);
				} else {
					callback = thisObj.onFineChange;
				}
				callback.call(thisObj);
			}
		},


		setPad: function (thisObj, e, ofsX, ofsY) {
			var pointerAbs = jsc.getAbsPointerPos(e);
			var x = ofsX + pointerAbs.x - jsc._pointerOrigin.x - thisObj.padding - thisObj.insetWidth;
			var y = ofsY + pointerAbs.y - jsc._pointerOrigin.y - thisObj.padding - thisObj.insetWidth;

			var xVal = x * (360 / (thisObj.width - 1));
			var yVal = 100 - (y * (100 / (thisObj.height - 1)));

			switch (jsc.getPadYComponent(thisObj)) {
				case 's':
					thisObj.fromHSV(xVal, yVal, null, jsc.leaveSld);
					break;
				case 'v':
					thisObj.fromHSV(xVal, null, yVal, jsc.leaveSld);
					break;
			}
		},


		setSld: function (thisObj, e, ofsY) {
			var pointerAbs = jsc.getAbsPointerPos(e);
			var y = ofsY + pointerAbs.y - jsc._pointerOrigin.y - thisObj.padding - thisObj.insetWidth;

			var yVal = 100 - (y * (100 / (thisObj.height - 1)));

			switch (jsc.getSliderComponent(thisObj)) {
				case 's':
					thisObj.fromHSV(null, yVal, null, jsc.leavePad);
					break;
				case 'v':
					thisObj.fromHSV(null, null, yVal, jsc.leavePad);
					break;
			}
		},


		_vmlNS: 'jsc_vml_',
		_vmlCSS: 'jsc_vml_css_',
		_vmlReady: false,


		initVML: function () {
			if (!jsc._vmlReady) {
				// init VML namespace
				var doc = document;
				if (!doc.namespaces[jsc._vmlNS]) {
					doc.namespaces.add(jsc._vmlNS, 'urn:schemas-microsoft-com:vml');
				}
				if (!doc.styleSheets[jsc._vmlCSS]) {
					var tags = ['shape', 'shapetype', 'group', 'background', 'path', 'formulas', 'handles', 'fill', 'stroke', 'shadow', 'textbox', 'textpath', 'imagedata', 'line', 'polyline', 'curve', 'rect', 'roundrect', 'oval', 'arc', 'image'];
					var ss = doc.createStyleSheet();
					ss.owningElement.id = jsc._vmlCSS;
					for (var i = 0; i < tags.length; i += 1) {
						ss.addRule(jsc._vmlNS + '\\:' + tags[i], 'behavior:url(#default#VML);');
					}
				}
				jsc._vmlReady = true;
			}
		},


		createPalette: function () {

			var paletteObj = {
				elm: null,
				draw: null
			};

			if (jsc.isCanvasSupported) {
				// Canvas implementation for modern browsers

				var canvas = document.createElement('canvas');
				var ctx = canvas.getContext('2d');

				var drawFunc = function (width, height, type) {
					canvas.width = width;
					canvas.height = height;

					ctx.clearRect(0, 0, canvas.width, canvas.height);

					var hGrad = ctx.createLinearGradient(0, 0, canvas.width, 0);
					hGrad.addColorStop(0 / 6, '#F00');
					hGrad.addColorStop(1 / 6, '#FF0');
					hGrad.addColorStop(2 / 6, '#0F0');
					hGrad.addColorStop(3 / 6, '#0FF');
					hGrad.addColorStop(4 / 6, '#00F');
					hGrad.addColorStop(5 / 6, '#F0F');
					hGrad.addColorStop(6 / 6, '#F00');

					ctx.fillStyle = hGrad;
					ctx.fillRect(0, 0, canvas.width, canvas.height);

					var vGrad = ctx.createLinearGradient(0, 0, 0, canvas.height);
					switch (type.toLowerCase()) {
						case 's':
							vGrad.addColorStop(0, 'rgba(255,255,255,0)');
							vGrad.addColorStop(1, 'rgba(255,255,255,1)');
							break;
						case 'v':
							vGrad.addColorStop(0, 'rgba(0,0,0,0)');
							vGrad.addColorStop(1, 'rgba(0,0,0,1)');
							break;
					}
					ctx.fillStyle = vGrad;
					ctx.fillRect(0, 0, canvas.width, canvas.height);
				};

				paletteObj.elm = canvas;
				paletteObj.draw = drawFunc;

			} else {
				// VML fallback for IE 7 and 8

				jsc.initVML();

				var vmlContainer = document.createElement('div');
				vmlContainer.style.position = 'relative';
				vmlContainer.style.overflow = 'hidden';

				var hGrad = document.createElement(jsc._vmlNS + ':fill');
				hGrad.type = 'gradient';
				hGrad.method = 'linear';
				hGrad.angle = '90';
				hGrad.colors = '16.67% #F0F, 33.33% #00F, 50% #0FF, 66.67% #0F0, 83.33% #FF0'

				var hRect = document.createElement(jsc._vmlNS + ':rect');
				hRect.style.position = 'absolute';
				hRect.style.left = -1 + 'px';
				hRect.style.top = -1 + 'px';
				hRect.stroked = false;
				hRect.appendChild(hGrad);
				vmlContainer.appendChild(hRect);

				var vGrad = document.createElement(jsc._vmlNS + ':fill');
				vGrad.type = 'gradient';
				vGrad.method = 'linear';
				vGrad.angle = '180';
				vGrad.opacity = '0';

				var vRect = document.createElement(jsc._vmlNS + ':rect');
				vRect.style.position = 'absolute';
				vRect.style.left = -1 + 'px';
				vRect.style.top = -1 + 'px';
				vRect.stroked = false;
				vRect.appendChild(vGrad);
				vmlContainer.appendChild(vRect);

				var drawFunc = function (width, height, type) {
					vmlContainer.style.width = width + 'px';
					vmlContainer.style.height = height + 'px';

					hRect.style.width =
						vRect.style.width =
							(width + 1) + 'px';
					hRect.style.height =
						vRect.style.height =
							(height + 1) + 'px';

					// Colors must be specified during every redraw, otherwise IE won't display
					// a full gradient during a subsequential redraw
					hGrad.color = '#F00';
					hGrad.color2 = '#F00';

					switch (type.toLowerCase()) {
						case 's':
							vGrad.color = vGrad.color2 = '#FFF';
							break;
						case 'v':
							vGrad.color = vGrad.color2 = '#000';
							break;
					}
				};

				paletteObj.elm = vmlContainer;
				paletteObj.draw = drawFunc;
			}

			return paletteObj;
		},


		createSliderGradient: function () {

			var sliderObj = {
				elm: null,
				draw: null
			};

			if (jsc.isCanvasSupported) {
				// Canvas implementation for modern browsers

				var canvas = document.createElement('canvas');
				var ctx = canvas.getContext('2d');

				var drawFunc = function (width, height, color1, color2) {
					canvas.width = width;
					canvas.height = height;

					ctx.clearRect(0, 0, canvas.width, canvas.height);

					var grad = ctx.createLinearGradient(0, 0, 0, canvas.height);
					grad.addColorStop(0, color1);
					grad.addColorStop(1, color2);

					ctx.fillStyle = grad;
					ctx.fillRect(0, 0, canvas.width, canvas.height);
				};

				sliderObj.elm = canvas;
				sliderObj.draw = drawFunc;

			} else {
				// VML fallback for IE 7 and 8

				jsc.initVML();

				var vmlContainer = document.createElement('div');
				vmlContainer.style.position = 'relative';
				vmlContainer.style.overflow = 'hidden';

				var grad = document.createElement(jsc._vmlNS + ':fill');
				grad.type = 'gradient';
				grad.method = 'linear';
				grad.angle = '180';

				var rect = document.createElement(jsc._vmlNS + ':rect');
				rect.style.position = 'absolute';
				rect.style.left = -1 + 'px';
				rect.style.top = -1 + 'px';
				rect.stroked = false;
				rect.appendChild(grad);
				vmlContainer.appendChild(rect);

				var drawFunc = function (width, height, color1, color2) {
					vmlContainer.style.width = width + 'px';
					vmlContainer.style.height = height + 'px';

					rect.style.width = (width + 1) + 'px';
					rect.style.height = (height + 1) + 'px';

					grad.color = color1;
					grad.color2 = color2;
				};

				sliderObj.elm = vmlContainer;
				sliderObj.draw = drawFunc;
			}

			return sliderObj;
		},


		leaveValue: 1 << 0,
		leaveStyle: 1 << 1,
		leavePad: 1 << 2,
		leaveSld: 1 << 3,


		BoxShadow: (function () {
			var BoxShadow = function (hShadow, vShadow, blur, spread, color, inset) {
				this.hShadow = hShadow;
				this.vShadow = vShadow;
				this.blur = blur;
				this.spread = spread;
				this.color = color;
				this.inset = !!inset;
			};

			BoxShadow.prototype.toString = function () {
				var vals = [
					Math.round(this.hShadow) + 'px',
					Math.round(this.vShadow) + 'px',
					Math.round(this.blur) + 'px',
					Math.round(this.spread) + 'px',
					this.color
				];
				if (this.inset) {
					vals.push('inset');
				}
				return vals.join(' ');
			};

			return BoxShadow;
		})(),


		//
		// Usage:
		// var myColor = new jscolor(<targetElement> [, <options>])
		//

		jscolor: function (targetElement, options) {

			// General options
			//
			this.value = null; // initial HEX color. To change it later, use methods fromString(), fromHSV() and fromRGB()
			this.valueElement = targetElement; // element that will be used to display and input the color code
			this.styleElement = targetElement; // element that will preview the picked color using CSS backgroundColor
			this.required = true; // whether the associated text <input> can be left empty
			this.refine = true; // whether to refine the entered color code (e.g. uppercase it and remove whitespace)
			this.hash = false; // whether to prefix the HEX color code with # symbol
			this.uppercase = true; // whether to uppercase the color code
			this.onFineChange = null; // called instantly every time the color changes (value can be either a function or a string with javascript code)
			this.activeClass = 'jscolor-active'; // class to be set to the target element when a picker window is open on it
			this.minS = 0; // min allowed saturation (0 - 100)
			this.maxS = 100; // max allowed saturation (0 - 100)
			this.minV = 0; // min allowed value (brightness) (0 - 100)
			this.maxV = 100; // max allowed value (brightness) (0 - 100)

			// Accessing the picked color
			//
			this.hsv = [0, 0, 100]; // read-only  [0-360, 0-100, 0-100]
			this.rgb = [255, 255, 255]; // read-only  [0-255, 0-255, 0-255]

			// Color Picker options
			//
			this.width = 181; // width of color palette (in px)
			this.height = 101; // height of color palette (in px)
			this.showOnClick = true; // whether to display the color picker when user clicks on its target element
			this.mode = 'HSV'; // HSV | HVS | HS | HV - layout of the color picker controls
			this.position = 'bottom'; // left | right | top | bottom - position relative to the target element
			this.smartPosition = true; // automatically change picker position when there is not enough space for it
			this.sliderSize = 16; // px
			this.crossSize = 8; // px
			this.closable = false; // whether to display the Close button
			this.closeText = 'Close';
			this.buttonColor = '#000000'; // CSS color
			this.buttonHeight = 18; // px
			this.padding = 12; // px
			this.backgroundColor = '#FFFFFF'; // CSS color
			this.borderWidth = 1; // px
			this.borderColor = '#BBBBBB'; // CSS color
			this.borderRadius = 0; // px
			this.insetWidth = 1; // px
			this.insetColor = '#BBBBBB'; // CSS color
			this.shadow = true; // whether to display shadow
			this.shadowBlur = 15; // px
			this.shadowColor = 'rgba(0,0,0,0.2)'; // CSS color
			this.pointerColor = '#4C4C4C'; // px
			this.pointerBorderColor = '#FFFFFF'; // px
			this.pointerBorderWidth = 1; // px
			this.pointerThickness = 2; // px
			this.zIndex = 1000;
			this.container = null; // where to append the color picker (BODY element by default)


			for (var opt in options) {
				if (options.hasOwnProperty(opt)) {
					this[opt] = options[opt];
				}
			}


			this.hide = function () {
				if (isPickerOwner()) {
					detachPicker();
				}
			};


			this.show = function () {
				drawPicker();
			};


			this.redraw = function () {
				if (isPickerOwner()) {
					drawPicker();
				}
			};


			this.importColor = function () {
				if (!this.valueElement) {
					this.exportColor();
				} else {
					if (jsc.isElementType(this.valueElement, 'input')) {
						if (!this.refine) {
							if (!this.fromString(this.valueElement.value, jsc.leaveValue)) {
								if (this.styleElement) {
									this.styleElement.style.backgroundImage = this.styleElement._jscOrigStyle.backgroundImage;
									this.styleElement.style.backgroundColor = this.styleElement._jscOrigStyle.backgroundColor;
									this.styleElement.style.color = this.styleElement._jscOrigStyle.color;
								}
								this.exportColor(jsc.leaveValue | jsc.leaveStyle);
							}
						} else if (!this.required && /^\s*$/.test(this.valueElement.value)) {
							this.valueElement.value = '';
							if (this.styleElement) {
								this.styleElement.style.backgroundImage = this.styleElement._jscOrigStyle.backgroundImage;
								this.styleElement.style.backgroundColor = this.styleElement._jscOrigStyle.backgroundColor;
								this.styleElement.style.color = this.styleElement._jscOrigStyle.color;
							}
							this.exportColor(jsc.leaveValue | jsc.leaveStyle);

						} else if (this.fromString(this.valueElement.value)) {
							// managed to import color successfully from the value -> OK, don't do anything
						} else {
							this.exportColor();
						}
					} else {
						// not an input element -> doesn't have any value
						this.exportColor();
					}
				}
			};


			this.exportColor = function (flags) {
				if (!(flags & jsc.leaveValue) && this.valueElement) {
					var value = this.toString();
					if (this.uppercase) {
						value = value.toUpperCase();
					}
					if (this.hash) {
						value = '#' + value;
					}

					if (jsc.isElementType(this.valueElement, 'input')) {
						this.valueElement.value = value;
					} else {
						this.valueElement.innerHTML = value;
					}
				}
				if (!(flags & jsc.leaveStyle)) {
					if (this.styleElement) {
						this.styleElement.style.backgroundImage = 'none';
						this.styleElement.style.backgroundColor = '#' + this.toString();
						this.styleElement.style.color = this.isLight() ? '#000' : '#FFF';
					}
				}
				if (!(flags & jsc.leavePad) && isPickerOwner()) {
					redrawPad();
				}
				if (!(flags & jsc.leaveSld) && isPickerOwner()) {
					redrawSld();
				}
			};


			// h: 0-360
			// s: 0-100
			// v: 0-100
			//
			this.fromHSV = function (h, s, v, flags) { // null = don't change
				if (h !== null) {
					if (isNaN(h)) {
						return false;
					}
					h = Math.max(0, Math.min(360, h));
				}
				if (s !== null) {
					if (isNaN(s)) {
						return false;
					}
					s = Math.max(0, Math.min(100, this.maxS, s), this.minS);
				}
				if (v !== null) {
					if (isNaN(v)) {
						return false;
					}
					v = Math.max(0, Math.min(100, this.maxV, v), this.minV);
				}

				this.rgb = HSV_RGB(
					h === null ? this.hsv[0] : (this.hsv[0] = h),
					s === null ? this.hsv[1] : (this.hsv[1] = s),
					v === null ? this.hsv[2] : (this.hsv[2] = v)
				);

				this.exportColor(flags);
			};


			// r: 0-255
			// g: 0-255
			// b: 0-255
			//
			this.fromRGB = function (r, g, b, flags) { // null = don't change
				if (r !== null) {
					if (isNaN(r)) {
						return false;
					}
					r = Math.max(0, Math.min(255, r));
				}
				if (g !== null) {
					if (isNaN(g)) {
						return false;
					}
					g = Math.max(0, Math.min(255, g));
				}
				if (b !== null) {
					if (isNaN(b)) {
						return false;
					}
					b = Math.max(0, Math.min(255, b));
				}

				var hsv = RGB_HSV(
					r === null ? this.rgb[0] : r,
					g === null ? this.rgb[1] : g,
					b === null ? this.rgb[2] : b
				);
				if (hsv[0] !== null) {
					this.hsv[0] = Math.max(0, Math.min(360, hsv[0]));
				}
				if (hsv[2] !== 0) {
					this.hsv[1] = hsv[1] === null ? null : Math.max(0, this.minS, Math.min(100, this.maxS, hsv[1]));
				}
				this.hsv[2] = hsv[2] === null ? null : Math.max(0, this.minV, Math.min(100, this.maxV, hsv[2]));

				// update RGB according to final HSV, as some values might be trimmed
				var rgb = HSV_RGB(this.hsv[0], this.hsv[1], this.hsv[2]);
				this.rgb[0] = rgb[0];
				this.rgb[1] = rgb[1];
				this.rgb[2] = rgb[2];

				this.exportColor(flags);
			};


			this.fromString = function (str, flags) {
				var m;
				if (m = str.match(/^\W*([0-9A-F]{3}([0-9A-F]{3})?)\W*$/i)) {
					// HEX notation
					//

					if (m[1].length === 6) {
						// 6-char notation
						this.fromRGB(
							parseInt(m[1].substr(0, 2), 16),
							parseInt(m[1].substr(2, 2), 16),
							parseInt(m[1].substr(4, 2), 16),
							flags
						);
					} else {
						// 3-char notation
						this.fromRGB(
							parseInt(m[1].charAt(0) + m[1].charAt(0), 16),
							parseInt(m[1].charAt(1) + m[1].charAt(1), 16),
							parseInt(m[1].charAt(2) + m[1].charAt(2), 16),
							flags
						);
					}
					return true;

				} else if (m = str.match(/^\W*rgba?\(([^)]*)\)\W*$/i)) {
					var params = m[1].split(',');
					var re = /^\s*(\d*)(\.\d+)?\s*$/;
					var mR, mG, mB;
					if (
						params.length >= 3 &&
						(mR = params[0].match(re)) &&
						(mG = params[1].match(re)) &&
						(mB = params[2].match(re))
					) {
						var r = parseFloat((mR[1] || '0') + (mR[2] || ''));
						var g = parseFloat((mG[1] || '0') + (mG[2] || ''));
						var b = parseFloat((mB[1] || '0') + (mB[2] || ''));
						this.fromRGB(r, g, b, flags);
						return true;
					}
				}
				return false;
			};


			this.toString = function () {
				return (
					(0x100 | Math.round(this.rgb[0])).toString(16).substr(1) +
					(0x100 | Math.round(this.rgb[1])).toString(16).substr(1) +
					(0x100 | Math.round(this.rgb[2])).toString(16).substr(1)
				);
			};


			this.toHEXString = function () {
				return '#' + this.toString().toUpperCase();
			};


			this.toRGBString = function () {
				return ('rgb(' +
					Math.round(this.rgb[0]) + ',' +
					Math.round(this.rgb[1]) + ',' +
					Math.round(this.rgb[2]) + ')'
				);
			};


			this.isLight = function () {
				return (
					0.213 * this.rgb[0] +
					0.715 * this.rgb[1] +
					0.072 * this.rgb[2] >
					255 / 2
				);
			};


			this._processParentElementsInDOM = function () {
				if (this._linkedElementsProcessed) {
					return;
				}
				this._linkedElementsProcessed = true;

				var elm = this.targetElement;
				do {
					// If the target element or one of its parent nodes has fixed position,
					// then use fixed positioning instead
					//
					// Note: In Firefox, getComputedStyle returns null in a hidden iframe,
					// that's why we need to check if the returned style object is non-empty
					var currStyle = jsc.getStyle(elm);
					if (currStyle && currStyle.position.toLowerCase() === 'fixed') {
						this.fixed = true;
					}

					if (elm !== this.targetElement) {
						// Ensure to attach onParentScroll only once to each parent element
						// (multiple targetElements can share the same parent nodes)
						//
						// Note: It's not just offsetParents that can be scrollable,
						// that's why we loop through all parent nodes
						if (!elm._jscEventsAttached) {
							jsc.attachEvent(elm, 'scroll', jsc.onParentScroll);
							elm._jscEventsAttached = true;
						}
					}
				} while ((elm = elm.parentNode) && !jsc.isElementType(elm, 'body'));
			};


			// r: 0-255
			// g: 0-255
			// b: 0-255
			//
			// returns: [ 0-360, 0-100, 0-100 ]
			//
			function RGB_HSV(r, g, b) {
				r /= 255;
				g /= 255;
				b /= 255;
				var n = Math.min(Math.min(r, g), b);
				var v = Math.max(Math.max(r, g), b);
				var m = v - n;
				if (m === 0) {
					return [null, 0, 100 * v];
				}
				var h = r === n ? 3 + (b - g) / m : (g === n ? 5 + (r - b) / m : 1 + (g - r) / m);
				return [
					60 * (h === 6 ? 0 : h),
					100 * (m / v),
					100 * v
				];
			}


			// h: 0-360
			// s: 0-100
			// v: 0-100
			//
			// returns: [ 0-255, 0-255, 0-255 ]
			//
			function HSV_RGB(h, s, v) {
				var u = 255 * (v / 100);

				if (h === null) {
					return [u, u, u];
				}

				h /= 60;
				s /= 100;

				var i = Math.floor(h);
				var f = i % 2 ? h - i : 1 - (h - i);
				var m = u * (1 - s);
				var n = u * (1 - s * f);
				switch (i) {
					case 6:
					case 0:
						return [u, n, m];
					case 1:
						return [n, u, m];
					case 2:
						return [m, u, n];
					case 3:
						return [m, n, u];
					case 4:
						return [n, m, u];
					case 5:
						return [u, m, n];
				}
			}


			function detachPicker() {
				jsc.unsetClass(THIS.targetElement, THIS.activeClass);
				jsc.picker.wrap.parentNode.removeChild(jsc.picker.wrap);
				delete jsc.picker.owner;
			}


			function drawPicker() {

				// At this point, when drawing the picker, we know what the parent elements are
				// and we can do all related DOM operations, such as registering events on them
				// or checking their positioning
				THIS._processParentElementsInDOM();

				if (!jsc.picker) {
					jsc.picker = {
						owner: null,
						wrap: document.createElement('div'),
						box: document.createElement('div'),
						boxS: document.createElement('div'), // shadow area
						boxB: document.createElement('div'), // border
						pad: document.createElement('div'),
						padB: document.createElement('div'), // border
						padM: document.createElement('div'), // mouse/touch area
						padPal: jsc.createPalette(),
						cross: document.createElement('div'),
						crossBY: document.createElement('div'), // border Y
						crossBX: document.createElement('div'), // border X
						crossLY: document.createElement('div'), // line Y
						crossLX: document.createElement('div'), // line X
						sld: document.createElement('div'),
						sldB: document.createElement('div'), // border
						sldM: document.createElement('div'), // mouse/touch area
						sldGrad: jsc.createSliderGradient(),
						sldPtrS: document.createElement('div'), // slider pointer spacer
						sldPtrIB: document.createElement('div'), // slider pointer inner border
						sldPtrMB: document.createElement('div'), // slider pointer middle border
						sldPtrOB: document.createElement('div'), // slider pointer outer border
						btn: document.createElement('div'),
						btnT: document.createElement('span') // text
					};

					jsc.picker.pad.appendChild(jsc.picker.padPal.elm);
					jsc.picker.padB.appendChild(jsc.picker.pad);
					jsc.picker.cross.appendChild(jsc.picker.crossBY);
					jsc.picker.cross.appendChild(jsc.picker.crossBX);
					jsc.picker.cross.appendChild(jsc.picker.crossLY);
					jsc.picker.cross.appendChild(jsc.picker.crossLX);
					jsc.picker.padB.appendChild(jsc.picker.cross);
					jsc.picker.box.appendChild(jsc.picker.padB);
					jsc.picker.box.appendChild(jsc.picker.padM);

					jsc.picker.sld.appendChild(jsc.picker.sldGrad.elm);
					jsc.picker.sldB.appendChild(jsc.picker.sld);
					jsc.picker.sldB.appendChild(jsc.picker.sldPtrOB);
					jsc.picker.sldPtrOB.appendChild(jsc.picker.sldPtrMB);
					jsc.picker.sldPtrMB.appendChild(jsc.picker.sldPtrIB);
					jsc.picker.sldPtrIB.appendChild(jsc.picker.sldPtrS);
					jsc.picker.box.appendChild(jsc.picker.sldB);
					jsc.picker.box.appendChild(jsc.picker.sldM);

					jsc.picker.btn.appendChild(jsc.picker.btnT);
					jsc.picker.box.appendChild(jsc.picker.btn);

					jsc.picker.boxB.appendChild(jsc.picker.box);
					jsc.picker.wrap.appendChild(jsc.picker.boxS);
					jsc.picker.wrap.appendChild(jsc.picker.boxB);
				}

				var p = jsc.picker;

				var displaySlider = !!jsc.getSliderComponent(THIS);
				var dims = jsc.getPickerDims(THIS);
				var crossOuterSize = (2 * THIS.pointerBorderWidth + THIS.pointerThickness + 2 * THIS.crossSize);
				var padToSliderPadding = jsc.getPadToSliderPadding(THIS);
				var borderRadius = Math.min(
					THIS.borderRadius,
					Math.round(THIS.padding * Math.PI)); // px
				var padCursor = 'crosshair';

				// wrap
				p.wrap.style.clear = 'both';
				p.wrap.style.width = (dims[0] + 2 * THIS.borderWidth) + 'px';
				p.wrap.style.height = (dims[1] + 2 * THIS.borderWidth) + 'px';
				p.wrap.style.zIndex = THIS.zIndex;

				// picker
				p.box.style.width = dims[0] + 'px';
				p.box.style.height = dims[1] + 'px';

				p.boxS.style.position = 'absolute';
				p.boxS.style.left = '0';
				p.boxS.style.top = '0';
				p.boxS.style.width = '100%';
				p.boxS.style.height = '100%';
				jsc.setBorderRadius(p.boxS, borderRadius + 'px');

				// picker border
				p.boxB.style.position = 'relative';
				p.boxB.style.border = THIS.borderWidth + 'px solid';
				p.boxB.style.borderColor = THIS.borderColor;
				p.boxB.style.background = THIS.backgroundColor;
				jsc.setBorderRadius(p.boxB, borderRadius + 'px');

				// IE hack:
				// If the element is transparent, IE will trigger the event on the elements under it,
				// e.g. on Canvas or on elements with border
				p.padM.style.background =
					p.sldM.style.background =
						'#FFF';
				jsc.setStyle(p.padM, 'opacity', '0');
				jsc.setStyle(p.sldM, 'opacity', '0');

				// pad
				p.pad.style.position = 'relative';
				p.pad.style.width = THIS.width + 'px';
				p.pad.style.height = THIS.height + 'px';

				// pad palettes (HSV and HVS)
				p.padPal.draw(THIS.width, THIS.height, jsc.getPadYComponent(THIS));

				// pad border
				p.padB.style.position = 'absolute';
				p.padB.style.left = THIS.padding + 'px';
				p.padB.style.top = THIS.padding + 'px';
				p.padB.style.border = THIS.insetWidth + 'px solid';
				p.padB.style.borderColor = THIS.insetColor;

				// pad mouse area
				p.padM._jscInstance = THIS;
				p.padM._jscControlName = 'pad';
				p.padM.style.position = 'absolute';
				p.padM.style.left = '0';
				p.padM.style.top = '0';
				p.padM.style.width = (THIS.padding + 2 * THIS.insetWidth + THIS.width + padToSliderPadding / 2) + 'px';
				p.padM.style.height = dims[1] + 'px';
				p.padM.style.cursor = padCursor;

				// pad cross
				p.cross.style.position = 'absolute';
				p.cross.style.left =
					p.cross.style.top =
						'0';
				p.cross.style.width =
					p.cross.style.height =
						crossOuterSize + 'px';

				// pad cross border Y and X
				p.crossBY.style.position =
					p.crossBX.style.position =
						'absolute';
				p.crossBY.style.background =
					p.crossBX.style.background =
						THIS.pointerBorderColor;
				p.crossBY.style.width =
					p.crossBX.style.height =
						(2 * THIS.pointerBorderWidth + THIS.pointerThickness) + 'px';
				p.crossBY.style.height =
					p.crossBX.style.width =
						crossOuterSize + 'px';
				p.crossBY.style.left =
					p.crossBX.style.top =
						(Math.floor(crossOuterSize / 2) - Math.floor(THIS.pointerThickness / 2) - THIS.pointerBorderWidth) + 'px';
				p.crossBY.style.top =
					p.crossBX.style.left =
						'0';

				// pad cross line Y and X
				p.crossLY.style.position =
					p.crossLX.style.position =
						'absolute';
				p.crossLY.style.background =
					p.crossLX.style.background =
						THIS.pointerColor;
				p.crossLY.style.height =
					p.crossLX.style.width =
						(crossOuterSize - 2 * THIS.pointerBorderWidth) + 'px';
				p.crossLY.style.width =
					p.crossLX.style.height =
						THIS.pointerThickness + 'px';
				p.crossLY.style.left =
					p.crossLX.style.top =
						(Math.floor(crossOuterSize / 2) - Math.floor(THIS.pointerThickness / 2)) + 'px';
				p.crossLY.style.top =
					p.crossLX.style.left =
						THIS.pointerBorderWidth + 'px';

				// slider
				p.sld.style.overflow = 'hidden';
				p.sld.style.width = THIS.sliderSize + 'px';
				p.sld.style.height = THIS.height + 'px';

				// slider gradient
				p.sldGrad.draw(THIS.sliderSize, THIS.height, '#000', '#000');

				// slider border
				p.sldB.style.display = displaySlider ? 'block' : 'none';
				p.sldB.style.position = 'absolute';
				p.sldB.style.right = THIS.padding + 'px';
				p.sldB.style.top = THIS.padding + 'px';
				p.sldB.style.border = THIS.insetWidth + 'px solid';
				p.sldB.style.borderColor = THIS.insetColor;

				// slider mouse area
				p.sldM._jscInstance = THIS;
				p.sldM._jscControlName = 'sld';
				p.sldM.style.display = displaySlider ? 'block' : 'none';
				p.sldM.style.position = 'absolute';
				p.sldM.style.right = '0';
				p.sldM.style.top = '0';
				p.sldM.style.width = (THIS.sliderSize + padToSliderPadding / 2 + THIS.padding + 2 * THIS.insetWidth) + 'px';
				p.sldM.style.height = dims[1] + 'px';
				p.sldM.style.cursor = 'default';

				// slider pointer inner and outer border
				p.sldPtrIB.style.border =
					p.sldPtrOB.style.border =
						THIS.pointerBorderWidth + 'px solid ' + THIS.pointerBorderColor;

				// slider pointer outer border
				p.sldPtrOB.style.position = 'absolute';
				p.sldPtrOB.style.left = -(2 * THIS.pointerBorderWidth + THIS.pointerThickness) + 'px';
				p.sldPtrOB.style.top = '0';

				// slider pointer middle border
				p.sldPtrMB.style.border = THIS.pointerThickness + 'px solid ' + THIS.pointerColor;

				// slider pointer spacer
				p.sldPtrS.style.width = THIS.sliderSize + 'px';
				p.sldPtrS.style.height = sliderPtrSpace + 'px';

				// the Close button
				function setBtnBorder() {
					var insetColors = THIS.insetColor.split(/\s+/);
					var outsetColor = insetColors.length < 2 ? insetColors[0] : insetColors[1] + ' ' + insetColors[0] + ' ' + insetColors[0] + ' ' + insetColors[1];
					p.btn.style.borderColor = outsetColor;
				}

				p.btn.style.display = THIS.closable ? 'block' : 'none';
				p.btn.style.position = 'absolute';
				p.btn.style.left = THIS.padding + 'px';
				p.btn.style.bottom = THIS.padding + 'px';
				p.btn.style.padding = '0 15px';
				p.btn.style.height = THIS.buttonHeight + 'px';
				p.btn.style.border = THIS.insetWidth + 'px solid';
				setBtnBorder();
				p.btn.style.color = THIS.buttonColor;
				p.btn.style.font = '12px sans-serif';
				p.btn.style.textAlign = 'center';
				try {
					p.btn.style.cursor = 'pointer';
				} catch (eOldIE) {
					p.btn.style.cursor = 'hand';
				}
				p.btn.onmousedown = function () {
					THIS.hide();
				};
				p.btnT.style.lineHeight = THIS.buttonHeight + 'px';
				p.btnT.innerHTML = '';
				p.btnT.appendChild(document.createTextNode(THIS.closeText));

				// place pointers
				redrawPad();
				redrawSld();

				// If we are changing the owner without first closing the picker,
				// make sure to first deal with the old owner
				if (jsc.picker.owner && jsc.picker.owner !== THIS) {
					jsc.unsetClass(jsc.picker.owner.targetElement, THIS.activeClass);
				}

				// Set the new picker owner
				jsc.picker.owner = THIS;

				// The redrawPosition() method needs picker.owner to be set, that's why we call it here,
				// after setting the owner
				if (jsc.isElementType(container, 'body')) {
					jsc.redrawPosition();
				} else {
					jsc._drawPosition(THIS, 0, 0, 'relative', false);
				}

				if (p.wrap.parentNode != container) {
					container.appendChild(p.wrap);
				}

				jsc.setClass(THIS.targetElement, THIS.activeClass);
			}


			function redrawPad() {
				// redraw the pad pointer
				switch (jsc.getPadYComponent(THIS)) {
					case 's':
						var yComponent = 1;
						break;
					case 'v':
						var yComponent = 2;
						break;
				}
				var x = Math.round((THIS.hsv[0] / 360) * (THIS.width - 1));
				var y = Math.round((1 - THIS.hsv[yComponent] / 100) * (THIS.height - 1));
				var crossOuterSize = (2 * THIS.pointerBorderWidth + THIS.pointerThickness + 2 * THIS.crossSize);
				var ofs = -Math.floor(crossOuterSize / 2);
				jsc.picker.cross.style.left = (x + ofs) + 'px';
				jsc.picker.cross.style.top = (y + ofs) + 'px';

				// redraw the slider
				switch (jsc.getSliderComponent(THIS)) {
					case 's':
						var rgb1 = HSV_RGB(THIS.hsv[0], 100, THIS.hsv[2]);
						var rgb2 = HSV_RGB(THIS.hsv[0], 0, THIS.hsv[2]);
						var color1 = 'rgb(' +
							Math.round(rgb1[0]) + ',' +
							Math.round(rgb1[1]) + ',' +
							Math.round(rgb1[2]) + ')';
						var color2 = 'rgb(' +
							Math.round(rgb2[0]) + ',' +
							Math.round(rgb2[1]) + ',' +
							Math.round(rgb2[2]) + ')';
						jsc.picker.sldGrad.draw(THIS.sliderSize, THIS.height, color1, color2);
						break;
					case 'v':
						var rgb = HSV_RGB(THIS.hsv[0], THIS.hsv[1], 100);
						var color1 = 'rgb(' +
							Math.round(rgb[0]) + ',' +
							Math.round(rgb[1]) + ',' +
							Math.round(rgb[2]) + ')';
						var color2 = '#000';
						jsc.picker.sldGrad.draw(THIS.sliderSize, THIS.height, color1, color2);
						break;
				}
			}


			function redrawSld() {
				var sldComponent = jsc.getSliderComponent(THIS);
				if (sldComponent) {
					// redraw the slider pointer
					switch (sldComponent) {
						case 's':
							var yComponent = 1;
							break;
						case 'v':
							var yComponent = 2;
							break;
					}
					var y = Math.round((1 - THIS.hsv[yComponent] / 100) * (THIS.height - 1));
					jsc.picker.sldPtrOB.style.top = (y - (2 * THIS.pointerBorderWidth + THIS.pointerThickness) - Math.floor(sliderPtrSpace / 2)) + 'px';
				}
			}


			function isPickerOwner() {
				return jsc.picker && jsc.picker.owner === THIS;
			}


			function blurValue() {
				THIS.importColor();
			}


			// Find the target element
			if (typeof targetElement === 'string') {
				var id = targetElement;
				var elm = document.getElementById(id);
				if (elm) {
					this.targetElement = elm;
				} else {
					jsc.warn('Could not find target element with ID \'' + id + '\'');
				}
			} else if (targetElement) {
				this.targetElement = targetElement;
			} else {
				jsc.warn('Invalid target element: \'' + targetElement + '\'');
			}

			if (this.targetElement._jscLinkedInstance) {
				jsc.warn('Cannot link jscolor twice to the same element. Skipping.');
				return;
			}
			this.targetElement._jscLinkedInstance = this;

			// Find the value element
			this.valueElement = jsc.fetchElement(this.valueElement);
			// Find the style element
			this.styleElement = jsc.fetchElement(this.styleElement);

			var THIS = this;
			var container =
				this.container ?
					jsc.fetchElement(this.container) :
					document.getElementsByTagName('body')[0];
			var sliderPtrSpace = 3; // px

			// For BUTTON elements it's important to stop them from sending the form when clicked
			// (e.g. in Safari)
			if (jsc.isElementType(this.targetElement, 'button')) {
				if (this.targetElement.onclick) {
					var origCallback = this.targetElement.onclick;
					this.targetElement.onclick = function (evt) {
						origCallback.call(this, evt);
						return false;
					};
				} else {
					this.targetElement.onclick = function () {
						return false;
					};
				}
			}

			/*
			 var elm = this.targetElement;
			 do {
			 // If the target element or one of its offsetParents has fixed position,
			 // then use fixed positioning instead
			 //
			 // Note: In Firefox, getComputedStyle returns null in a hidden iframe,
			 // that's why we need to check if the returned style object is non-empty
			 var currStyle = jsc.getStyle(elm);
			 if (currStyle && currStyle.position.toLowerCase() === 'fixed') {
			 this.fixed = true;
			 }

			 if (elm !== this.targetElement) {
			 // attach onParentScroll so that we can recompute the picker position
			 // when one of the offsetParents is scrolled
			 if (!elm._jscEventsAttached) {
			 jsc.attachEvent(elm, 'scroll', jsc.onParentScroll);
			 elm._jscEventsAttached = true;
			 }
			 }
			 } while ((elm = elm.offsetParent) && !jsc.isElementType(elm, 'body'));
			 */

			// valueElement
			if (this.valueElement) {
				if (jsc.isElementType(this.valueElement, 'input')) {
					var updateField = function () {
						THIS.fromString(THIS.valueElement.value, jsc.leaveValue);
						jsc.dispatchFineChange(THIS);
					};
					jsc.attachEvent(this.valueElement, 'keyup', updateField);
					jsc.attachEvent(this.valueElement, 'input', updateField);
					jsc.attachEvent(this.valueElement, 'blur', blurValue);
					this.valueElement.setAttribute('autocomplete', 'off');
				}
			}

			// styleElement
			if (this.styleElement) {
				this.styleElement._jscOrigStyle = {
					backgroundImage: this.styleElement.style.backgroundImage,
					backgroundColor: this.styleElement.style.backgroundColor,
					color: this.styleElement.style.color
				};
			}

			if (this.value) {
				// Try to set the color from the .value option and if unsuccessful,
				// export the current color
				this.fromString(this.value) || this.exportColor();
			} else {
				this.importColor();
			}
		}

	};


//================================
// Public properties and methods
//================================


// By default, search for all elements with class="jscolor" and install a color picker on them.
//
// You can change what class name will be looked for by setting the property jscolor.lookupClass
// anywhere in your HTML document. To completely disable the automatic lookup, set it to null.
//
	jsc.jscolor.lookupClass = 'colorpicker';


	jsc.jscolor.installByClassName = function (className) {
		var inputElms = document.getElementsByTagName('input');
		var buttonElms = document.getElementsByTagName('button');

		jsc.tryInstallOnElements(inputElms, className);
		jsc.tryInstallOnElements(buttonElms, className);
	};


	return jsc;


});